home *** CD-ROM | disk | FTP | other *** search
/ BMUG PD-ROM 1995 Fall / PD-ROM F95.toast / Telecom / Terminal Programs / Terminal 2.0.1 ƒ / Srcs / Utilities.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-19  |  15.7 KB  |  698 lines  |  [TEXT/ttxt]
  1. /*
  2.     Terminal 2.0
  3.     "Utilities.c"
  4. */
  5.  
  6. #ifdef THINK_C
  7. #include "MacHeaders"
  8. #endif
  9. #ifdef applec
  10. #pragma load ":(Objects):MacHeadersMPW"
  11. #pragma segment Main
  12. #endif
  13.  
  14. #include "Utilities.h"
  15. #include "Text.h"
  16. #include "Main.h"
  17. #include "Document.h"
  18.  
  19. /* ----- Calculate number of bytes to make multiple of block size ------ */
  20.  
  21. short Filler(register short blocksize, register long n)
  22. {
  23.     register short i;
  24.  
  25.     return (i = n % blocksize) ? blocksize - i : 0;
  26. }
  27.  
  28. /* ----- Get pointer to string ----------------------------------------- */
  29.  
  30. Byte *MyString(short id, register short number)
  31. {
  32.     register Handle h;
  33.     register Byte *p;
  34.     register short i;
  35.     register short n;
  36.  
  37.     h = GetResource('STR#', id);
  38.     p = (Byte *)*h;
  39.     n = *(short *)p;
  40.     p += 2;
  41.     for (i = 1; i <= n; i++, p += *p + 1)
  42.         if (i == number)
  43.             return p;
  44.     return 0;
  45. }
  46.  
  47. /* ----- Append string2 to string1 ------------------------------------- */
  48.  
  49. Byte *Append(register Byte *s1, register Byte *s2)
  50. {
  51.     register short d, n, i;
  52.  
  53.     n = *s1;
  54.     d = *s2;
  55.     i = n + d - 255;
  56.     if (i > 0)
  57.         d -= i;
  58.     *s1 = n + d;
  59.     memcpy(s1 + n + 1, s2 + 1, d);
  60.     return s1;
  61. }
  62.  
  63. #ifdef OUTLINE
  64. /* ----- Outline button in dialog -------------------------------------- */
  65.  
  66. void OutLine(dialog, item, mode)
  67. register DialogPtr dialog;
  68. register short item;
  69. register short mode;
  70. {
  71.     short kind;
  72.     Handle h;
  73.     Rect r;
  74.     PenState state;
  75.  
  76.     SetPort(dialog);
  77.     GetPenState(&state);
  78.     GetDItem(dialog, item, &kind, &h, &r);
  79.     PenMode(mode);
  80.     PenPat(QD(black));
  81.     PenSize(3, 3);
  82.     InsetRect(&r, -4, -4);
  83.     FrameRoundRect(&r, 16, 16);
  84.     SetPenState(&state);
  85. }
  86. #endif
  87.  
  88. /* ----- Get edit text field in a dialog ------------------------------- */
  89.  
  90. void GetEText(
  91.     register DialogPtr dPtr,
  92.     register short item,
  93.     register Byte *str)
  94. {
  95.     short theType;
  96.     Handle theItem;
  97.     Rect theBox;
  98.  
  99.     GetDItem(dPtr, item, &theType, &theItem, &theBox);
  100.     GetIText(theItem, str);
  101. }
  102.  
  103. /* ----- Set edit text field in a dialog ------------------------------- */
  104.  
  105. void SetEText(
  106.     register DialogPtr dPtr,
  107.     register short item,
  108.     register Byte *str)
  109. {
  110.     short theType;
  111.     Handle theItem;
  112.     Rect theBox;
  113.  
  114.     GetDItem(dPtr, item, &theType, &theItem, &theBox);
  115.     SetIText(theItem, str);
  116. }
  117.  
  118. /* ----- Get the value of a control ------------------------------------ */
  119.  
  120. short GetCheck(
  121.     register DialogPtr dPtr,
  122.     register short ChkItem)
  123. {
  124.     short theType;
  125.     Handle theItem;
  126.     Rect theBox;
  127.  
  128.     GetDItem(dPtr, ChkItem, &theType, &theItem, &theBox);
  129.     return GetCtlValue((ControlHandle)theItem);
  130. }
  131.  
  132. /* ----- Set the value of a control ------------------------------------ */
  133.  
  134. void SetCheck(
  135.     register DialogPtr dPtr,
  136.     short ChkItem,
  137.     short value)
  138. {
  139.     short theType;
  140.     Handle theItem;
  141.     Rect theBox;
  142.  
  143.     GetDItem(dPtr, ChkItem, &theType, &theItem, &theBox);
  144.     SetCtlValue((ControlHandle)theItem, value);
  145. }
  146.  
  147. /* ----- Hilite control ----------------------------------------------- */
  148.  
  149. void SetHilite(
  150.     register DialogPtr dPtr,
  151.     short ChkItem,
  152.     short Value)
  153. {
  154.     short theType;
  155.     Handle theItem;
  156.     Rect theBox;
  157.  
  158.     GetDItem(dPtr, ChkItem, &theType, &theItem, &theBox);
  159.     HiliteControl((ControlHandle)theItem, Value);
  160. }
  161.  
  162. /* ----- Center dialog or alert template ------------------------------- */
  163.  
  164. void CenterDialog(
  165.     register long templateType,    /* 'ALRT' or 'DLOG' */
  166.     register short templateID)
  167. {
  168.     register Rect *p;
  169.     register Rect **h;    /* Templates start with boundsRect */
  170.     register short width, height;
  171.     Rect r = QD(screenBits.bounds);
  172.     
  173.     if (!(h = (Rect **)GetResource(templateType, templateID)))
  174.         return;
  175.     r.top += MBarHeight;
  176.     p = *h;
  177.     width = p->right - p->left;
  178.     height = p->bottom - p->top;
  179.     p->top = r.top + ((r.bottom - r.top - height) / 3);
  180.     p->bottom = p->top + height;
  181.     p->left = r.left + ((r.right - r.left - width) / 2);
  182.     p->right = p->left + width;
  183. }
  184.  
  185. /* ----- Calculate where to put a centered dialog box ------------------ */
  186.  
  187. void GetDlogOrigin(
  188.     register short dlogID,
  189.     register Point *where)
  190. {
  191.     register Rect *p;
  192.     register Rect **h;    /* Templates start with boundsRect */
  193.     Rect r = QD(screenBits.bounds);
  194.  
  195.     if (!(h = (Rect **)GetResource('DLOG', dlogID))) {
  196.         where->v = where->h = 80;
  197.         return;
  198.     }
  199.     r.top += MBarHeight;
  200.     p = *h;
  201.     where->h = r.left + ((r.right - r.left - (p->right - p->left)) / 2);
  202.     where->v = r.top + ((r.bottom - r.top - (p->bottom - p->top)) / 3);
  203. }
  204.  
  205. /* ----- Toggle value of checkbox -------------------------------------- */
  206.  
  207. void ToggleCheckBox(
  208.     register DialogPtr dialog,
  209.     register short item)
  210. {
  211.     short type;
  212.     Handle itemHdl;
  213.     Rect box;
  214.  
  215.     GetDItem(dialog, item, &type, &itemHdl, &box);
  216.     SetCtlValue((ControlHandle)itemHdl,
  217.         (GetCtlValue((ControlHandle)itemHdl) == 0) ? 1 : 0);
  218. }
  219.  
  220. /* ----- Set group of radio buttons ------------------------------------ */
  221.  
  222. Boolean SetRadioButton(
  223.     register DialogPtr dialog,
  224.     register short item1,
  225.     register short item2,
  226.     register short item)
  227. {
  228.     register short i;
  229.     short type;
  230.     Handle itemHdl;
  231.     Rect box;
  232.  
  233.     if (item < item1 || item > item2)
  234.         return FALSE;
  235.     for (i = item1; i <= item2; i++) {
  236.         GetDItem(dialog, i, &type, &itemHdl, &box);
  237.         SetCtlValue((ControlHandle)itemHdl, (item == i) ? 1 : 0);
  238.     }
  239.     return TRUE;
  240. }
  241.  
  242. /* ----- Get group of radio buttons ------------------------------------ */
  243.  
  244. short GetRadioButton(
  245.     register DialogPtr dialog,
  246.     register short item1,
  247.     register short item2)
  248. {
  249.     register short i;
  250.     short type;
  251.     Handle itemHdl;
  252.     Rect box;
  253.  
  254.     for (i = item1; i <= item2; i++) {
  255.         GetDItem(dialog, i, &type, &itemHdl, &box);
  256.         if (GetCtlValue((ControlHandle)itemHdl))
  257.             return i;
  258.     }
  259.     return 0;
  260. }
  261.  
  262. #ifdef OUTLINE
  263. /* ----- Filter function for dialog ------------------------------------ */
  264.  
  265. /*
  266.     Outline the "Ok" button (item #1) and convert "Return" and "Enter"
  267.     keys to item #1.
  268. */
  269.  
  270. pascal Boolean OutlineFilter(dialog, event, item)
  271. register DialogPtr dialog;
  272. register EventRecord *event;
  273. short *item;
  274. {
  275.     register unsigned char key;
  276.     DialogPtr dp;
  277.     short i;
  278.  
  279.     switch (event->what) {
  280.         case updateEvt:
  281.             /* Proper handling of update events to avoid continous calls
  282.             to our filter function with update events (flickering):
  283.             Other dialog boxes may appear on the screen and disappear,
  284.             generating update events both for themselves and for other
  285.             windows allready on the screen. They must be handled
  286.             immediatly  and then cleared via BeginUpdate() / EndUpdate().
  287.             Otherwise the system will keep reporting the same event over
  288.             and over again. */
  289.             if (!SystemEvent(event)) {    /* SystemEvent() does updating */
  290.                 if (IsDialogEvent(event)) {            /* Dialog Window? */
  291.                     DialogSelect(event, &dp, &i);    /* Update dialog */
  292.                     if (dp == dialog)                /* If our dialog */
  293.                         OutLine(dialog, 1, patCopy);/* "Ok" button */
  294.                 } else
  295.                     RedrawDocument();        /* Update application window */
  296.             }
  297.             break;
  298.         case keyDown:
  299.         case autoKey:
  300.             key = event->message & charCodeMask;
  301.             if (key == '\015' || key == 0x03) {    /* "Return", "Enter" */
  302.                 *item = 1;                        /* Change to "Ok" button */
  303.                 return TRUE;                    /* We changed the event */
  304.             }
  305.             break;
  306.     }
  307.     return FALSE;    /* ModalDialog() should handle event */
  308. }
  309. #endif
  310.  
  311. /* ----- Draw user item in dialog -------------------------------------- */
  312.  
  313. pascal void DrawUserFrame(
  314.     register WindowPtr window,
  315.     register short number)
  316. {
  317.     short type;
  318.     Handle item;
  319.     Rect box, boxT;
  320.  
  321.     GetDItem(window, number - 1, &type, &item, &boxT);    /* Text */
  322.     GetDItem(window, number, &type, &item, &box);        /* User item */
  323.     PenPat(QD(gray));
  324.     MoveTo(boxT.right + 2, box.top);
  325.     LineTo(box.right, box.top);
  326.     LineTo(box.right, box.bottom);
  327.     LineTo(box.left, box.bottom);
  328.     LineTo(box.left, box.top);
  329.     LineTo(boxT.left - 3, box.top);
  330.     PenPat(QD(black));
  331. }
  332.  
  333. /* ----- Draw user item in dialog -------------------------------------- */
  334.  
  335. pascal void DrawUserLine(
  336.     register WindowPtr window,
  337.     register short number)
  338. {
  339.     short type;
  340.     Handle item;
  341.     Rect box;
  342.  
  343.     GetDItem(window, number, &type, &item, &box);        /* User item */
  344.     PenPat(QD(gray));
  345.     MoveTo(box.left, box.top);
  346.     LineTo(box.right, box.top);
  347.     MoveTo(box.left, box.bottom);
  348.     LineTo(box.right, box.bottom);
  349.     PenPat(QD(black));
  350. }
  351.  
  352. /* ----- Convert to full path name ------------------------------------- */
  353.  
  354. static short Path1name(
  355.     register Byte *name,
  356.     register long directory,
  357.     register CInfoPBRec *cat)
  358. {
  359.     register short err;
  360.     register Byte s[66];
  361.  
  362.     cat->dirInfo.ioNamePtr = (StringPtr)s;
  363.     cat->dirInfo.ioDrDirID = directory;
  364.     if (!(err = PBGetCatInfo(cat, FALSE))) {
  365.         if (directory != 2)
  366.             err = Path1name(name, cat->dirInfo.ioDrParID, cat);
  367.         if (!err) {
  368.             Append(s, (Byte *)"\p:");
  369.             Append(name, s);
  370.         }
  371.     }
  372.     return err;
  373. }
  374.  
  375. short Pathname(
  376.     register Byte *name,        /* Path name returned */
  377.     register short volume,        /* Volume reference number */
  378.     register long directory)    /* Directory ID */
  379. {
  380.     CInfoPBRec cat;
  381.  
  382.     memset(&cat, 0, sizeof(cat));
  383.     cat.dirInfo.ioVRefNum = volume;
  384.     cat.dirInfo.ioFDirIndex = -1;
  385.     name[0] = 0;
  386.     return Path1name(name, directory, &cat);
  387. }
  388.  
  389. /* ----- Normalize volume name and volume reference number ------------- */
  390.  
  391. short VolumeId(
  392.     register Byte *name,
  393.     register short *volume)
  394. {
  395.     register short err;
  396.     HParamBlockRec p;
  397.  
  398.     memset(&p, 0, sizeof(p));
  399.     if (*volume) {    /* Get corresponding volume name */
  400.         p.volumeParam.ioNamePtr = (StringPtr)name;
  401.         p.volumeParam.ioVRefNum = *volume;
  402.     } else {        /* Get corresponding volume reference number */
  403.         register Byte s[32];
  404.         memcpy(s, name, name[0] + 1);
  405.         s[++(s[0])] = ':';
  406.         p.volumeParam.ioNamePtr = (StringPtr)s;
  407.         p.volumeParam.ioVolIndex = -1;
  408.     }
  409.     err = PBHGetVInfo(&p, FALSE);
  410.     *volume = p.volumeParam.ioVRefNum;
  411.     return err;
  412. }
  413.  
  414. /* ----- Open file (data fork) ----------------------------------------- */
  415.  
  416. short OpenFile(
  417.     register short volume,
  418.     register long directory,
  419.     register Byte *name,
  420.     register short *ref)
  421. {
  422.     register short err;
  423.     HFileParam p;
  424.  
  425.     memset(&p, 0, sizeof(p));
  426.     p.ioVRefNum = volume;
  427.     p.ioDirID = directory;
  428.     p.ioNamePtr = (StringPtr)name;
  429.     *ref = (err = PBHOpen((HParmBlkPtr)&p, FALSE)) ? 0 : p.ioFRefNum;
  430.     return err;
  431. }
  432.  
  433. /* ----- Open file (resource fork) ------------------------------------- */
  434.  
  435. short OpenResource(
  436.     register short volume,
  437.     register long directory,
  438.     register Byte *name,
  439.     register short *ref)
  440. {
  441.     register short err;
  442.     HFileParam p;
  443.  
  444.     memset(&p, 0, sizeof(p));
  445.     p.ioVRefNum = volume;
  446.     p.ioDirID = directory;
  447. #ifdef THINK_C
  448.     p.ioNamePtr = (StringPtr)StripAddress((long)name);    /* TN #232 */
  449. #else
  450.     p.ioNamePtr = (StringPtr)StripAddress((Ptr)name);    /* TN #232 */
  451. #endif
  452.     *ref = (err = PBHOpenRF((HParmBlkPtr)&p, FALSE)) ? 0 : p.ioFRefNum;
  453.     return err;
  454. }
  455.  
  456. /* ----- Create file --------------------------------------------------- */
  457.  
  458. short CreateFile(
  459.     register short volume,
  460.     register long directory,
  461.     register Byte *name,
  462.     register long creator,
  463.     register long type)
  464. {
  465.     register short err;
  466.     HFileParam p;
  467.  
  468.     memset(&p, 0, sizeof(p));
  469.     p.ioNamePtr = (StringPtr)name;
  470.     p.ioVRefNum = volume;
  471.     p.ioDirID = directory;
  472.     if (err = PBHCreate((HParmBlkPtr)&p, FALSE))
  473.         return err;
  474.  
  475.     memset(&p, 0, sizeof(p));
  476.     p.ioNamePtr = (StringPtr)name;
  477.     p.ioVRefNum = volume;
  478.     p.ioDirID = directory;
  479.     if (err = PBHGetFInfo((HParmBlkPtr)&p, FALSE))
  480.         return err;
  481.     p.ioNamePtr = (StringPtr)name;
  482.     p.ioVRefNum = volume;
  483.     p.ioDirID = directory;
  484.     p.ioFlFndrInfo.fdCreator = creator;
  485.     p.ioFlFndrInfo.fdType = type;
  486.     return PBHSetFInfo((HParmBlkPtr)&p, FALSE);
  487. }
  488.  
  489. /* ----- Delete file --------------------------------------------------- */
  490.  
  491. short DeleteFile(
  492.     register short volume,
  493.     register long directory,
  494.     register Byte *name)
  495. {
  496.     HFileParam p;
  497.  
  498.     memset(&p, 0, sizeof(p));
  499.     p.ioNamePtr = (StringPtr)name;
  500.     p.ioVRefNum = volume;
  501.     p.ioDirID = directory;
  502.     return PBHDelete((HParmBlkPtr)&p, FALSE);
  503. }
  504.  
  505. /* ----- Get file info ------------------------------------------------- */
  506.  
  507. short InfoFile(
  508.     register short volume,        /* <- Volume reference number */
  509.     register long directory,    /* <- Directory id */
  510.     register Byte *name,        /* <- File name */
  511.     OSType *creator,            /* -> File creator */
  512.     OSType *type,                /* -> File type */
  513.     long *create,                /* -> File creation date */
  514.     long *modif)                /* -> File modification date */
  515. {
  516.     register short err;
  517.     HParamBlockRec p;
  518.  
  519.     memset(&p, 0, sizeof(p));
  520.     p.fileParam.ioNamePtr = (StringPtr)name;
  521.     p.fileParam.ioVRefNum = volume;
  522.     p.fileParam.ioDirID = directory;
  523.     if (err = PBHGetFInfo(&p, FALSE))
  524.         return err;
  525.     *creator = p.fileParam.ioFlFndrInfo.fdCreator;
  526.     *type = p.fileParam.ioFlFndrInfo.fdType;
  527.     *create = p.fileParam.ioFlCrDat;
  528.     *modif = p.fileParam.ioFlMdDat;
  529.     return err;
  530. }
  531.  
  532. /* ----- Set file info ------------------------------------------------- */
  533.  
  534. short SetInfoFile(
  535.     register short volume,        /* <- Volume reference number */
  536.     register long directory,    /* <- Directory id */
  537.     register Byte *name,        /* <- File name */
  538.     OSType creator,                /* <- File creator */
  539.     OSType type,                /* <- File type */
  540.     long create,                /* <- File creation date */
  541.     long modif)                    /* <- File modification date */
  542. {
  543.     register short err;
  544.     HParamBlockRec p;
  545.  
  546.     memset(&p, 0, sizeof(p));
  547.     p.fileParam.ioNamePtr = (StringPtr)name;
  548.     p.fileParam.ioVRefNum = volume;
  549.     p.fileParam.ioDirID = directory;
  550.     if (err = PBHGetFInfo(&p, FALSE))
  551.         return err;
  552.     p.fileParam.ioNamePtr = name;
  553.     p.fileParam.ioVRefNum = volume;
  554.     p.fileParam.ioDirID = directory;
  555.     p.fileParam.ioFlFndrInfo.fdCreator = creator;
  556.     p.fileParam.ioFlFndrInfo.fdType = type;
  557.     p.fileParam.ioFlCrDat = create;
  558.     p.fileParam.ioFlMdDat = modif;
  559.     return PBHSetFInfo(&p, FALSE);
  560. }
  561.  
  562. /* ----- Rename file --------------------------------------------------- */
  563.  
  564. short FileRename(
  565.     register short volume,
  566.     register long directory,
  567.     register Byte *oldname,
  568.     register Byte *newname)
  569. {
  570.     HParamBlockRec p;
  571.  
  572.     memset(&p, 0, sizeof(p));
  573.     p.fileParam.ioNamePtr = (StringPtr)oldname;
  574.     p.fileParam.ioVRefNum = volume;
  575.     p.fileParam.ioDirID = directory;
  576.     p.ioParam.ioMisc = (Ptr)newname;
  577.     return PBHRename(&p, FALSE);
  578. }
  579.  
  580. /* ----- Set user item in dialogs -------------------------------------- */
  581.  
  582. void SetUserItem(
  583.     register DialogPtr dialog,
  584.     register short item,
  585.     register ProcPtr function)
  586. {
  587.     short type;
  588.     Handle h;
  589.     Rect box;
  590.  
  591.     GetDItem(dialog, item, &type, &h, &box);
  592.     SetDItem(dialog, item, userItem, (Handle)function, &box);
  593. }
  594.  
  595. /* ----- Activate/deactivate controls in dialog ------------------------ */
  596.  
  597. void ActivateDeactivate(
  598.     register DialogPtr dialog,
  599.     register short item,
  600.     register Boolean activate)
  601. {
  602.     short type;
  603.     Handle h;
  604.     Rect box;
  605.  
  606.     GetDItem(dialog, item, &type, &h, &box);
  607.     HiliteControl((ControlHandle)h, activate ? 0 : 255);
  608. }
  609.  
  610. /* ----- Get size of biggest temporary memory -------------------------- */
  611.  
  612. #define RESERVE    0x1000L
  613.  
  614. unsigned long MaxBuffer(register Boolean *mf)
  615. {
  616.     register unsigned long max, max2;
  617.     long grow;
  618.  
  619.     max = MaxMem(&grow);
  620.     *mf = FALSE;
  621.     if (MFmemory && ((max2 = MFMaxMem(&grow)) > max)) {
  622.         *mf = TRUE;
  623.         max = max2;
  624.     }
  625.     return max < RESERVE ? 0 : max - RESERVE;
  626. }
  627.  
  628. /* ----- Allocate new buffer in temporary memory ----------------------- */
  629.  
  630. Handle NewBuffer(register unsigned long size, register Boolean mf)
  631. {
  632.     register Handle h;
  633.     short err;
  634.  
  635.     if (MFmemory && mf) {
  636.         if (h = MFTempNewHandle(size, &err))
  637.             MFTempHLock(h, &err);
  638.     } else {
  639.         if (h = NewHandle(size))
  640.             HLock(h);
  641.     }
  642.     return h;
  643. }
  644.  
  645. /* ----- Dispose of buffer in temporary memory ------------------------- */
  646.  
  647. void DisposeBuffer(register Handle h, register Boolean mf)
  648. {
  649.     short err;
  650.  
  651.     if (h) {
  652.         if (mf)
  653.             MFTempDisposHandle(h, &err);
  654.         else
  655.             DisposHandle(h);
  656.     }
  657. }
  658.  
  659. /* ----- Check suffix -------------------------------------------------- */
  660.  
  661. Boolean CheckSuffix(register Byte *name, register Byte *suffix)
  662. {
  663.     register Byte *p;
  664.     register Byte *q;
  665.  
  666.     for (p = name + *name,
  667.             q = suffix + *suffix; ; --p, --q) {
  668.         if (q == suffix)
  669.             return TRUE;    /* Ok: name ends in suffix */
  670.         if (p == name || *q != *p)
  671.             return FALSE;    /* Sorry */
  672.     }
  673. }
  674.  
  675. /* ----- Keydown handler for dialog filters ---------------------------- */
  676.  
  677. Boolean DialogKeydown(
  678.     register DialogPtr dialog,
  679.     register EventRecord *event,
  680.     register short *item)
  681. {
  682.     register Byte key = event->message & 0xFF;
  683.     short type;
  684.     Handle hdl;
  685.     Rect box;
  686.     long ignore;
  687.  
  688.     if (key == 0x03 || key == 0x0D)    {    /* Enter, return */
  689.         GetDItem(dialog, 1, &type, &hdl, &box);
  690.         HiliteControl((ControlHandle)hdl, 1);
  691.         Delay(3, &ignore);
  692.         HiliteControl((ControlHandle)hdl, 0);
  693.         *item = 1;
  694.         return TRUE;
  695.     }
  696.     return FALSE;
  697. }
  698.